/******************************************************************************
 * Copyright (c) 2022 Telink Semiconductor (Shanghai) Co., Ltd. ("TELINK")
 * All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *****************************************************************************/
#pragma once

#include "macro_trick.h"

#define BIT(n) (1 << (n))

// BITSx  are internal used macro, please use BITS instead
#define BITS1(a)                      BIT(a)
#define BITS2(a, b)                   (BIT(a) | BIT(b))
#define BITS3(a, b, c)                (BIT(a) | BIT(b) | BIT(c))
#define BITS4(a, b, c, d)             (BIT(a) | BIT(b) | BIT(c) | BIT(d))
#define BITS5(a, b, c, d, e)          (BIT(a) | BIT(b) | BIT(c) | BIT(d) | BIT(e))
#define BITS6(a, b, c, d, e, f)       (BIT(a) | BIT(b) | BIT(c) | BIT(d) | BIT(e) | BIT(f))
#define BITS7(a, b, c, d, e, f, g)    (BIT(a) | BIT(b) | BIT(c) | BIT(d) | BIT(e) | BIT(f) | BIT(g))
#define BITS8(a, b, c, d, e, f, g, h) (BIT(a) | BIT(b) | BIT(c) | BIT(d) | BIT(e) | BIT(f) | BIT(g) | BIT(h))

#define BITS(...) VARARG(BITS, __VA_ARGS__)

// bits range: BITS_RNG(4, 5)  0b000111110000,  start from 4, length = 5
#define BIT_RNG(s, e) (BIT_MASK_LEN((e) - (s) + 1) << (s))

#define BM_MASK_V(x, mask)     ((x) | (mask))
#define BM_CLR_MASK_V(x, mask) ((x) & ~(mask))

#define BM_SET(x, mask)    ((x) |= (mask))
#define BM_CLR(x, mask)    ((x) &= ~(mask))
#define BM_IS_SET(x, mask) ((x) & (mask))
#define BM_IS_CLR(x, mask) ((~(x)) & (mask))
#define BM_FLIP(x, mask)   ((x) ^= (mask))

// !!!!   v is already a masked value,  no need to shift
#define BM_MASK_VAL(x, mask, v)     (((x) & ~(mask)) | (v))
#define BM_SET_MASK_VAL(x, mask, v) ((x) = BM_MASK_VAL(x, mask, v))

#define BIT_SET(x, n)      ((x) |= BIT(n))
#define BIT_CLR(x, n)      ((x) &= ~BIT(n))
#define BIT_IS_SET(x, n)   ((x)&BIT(n))
#define BIT_FLIP(x, n)     ((x) ^= BIT(n))
#define BIT_SET_HIGH(x)    ((x) |= BIT((sizeof((x)) * 8 - 1)))   // set the highest bit
#define BIT_CLR_HIGH(x)    ((x) &= ~BIT((sizeof((x)) * 8 - 1)))  // clr the highest bit
#define BIT_IS_SET_HIGH(x) ((x)&BIT((sizeof((x)) * 8 - 1)))      // check the higest bit

#define BIT_MASK_LEN(len)    (BIT(len) - 1)
#define BIT_MASK(start, len) (BIT_MASK_LEN(len) << (start))

// ! Prepare a bitmask for insertion or combining.
#define BIT_PREP(x, start, len) ((x)&BIT_MASK(start, len))

// ! Extract a bitfield of length \a len starting at bit \a start from \a y.
#define BIT_GET(x, start, len) (((x) >> (start)) & BIT_MASK_LEN(len))
#define BIT_GET_LOW(x, len)    ((x)&BIT_MASK_LEN(len))

// ! Insert a new bitfield value \a x into \a y.
#define BIT_MERGE(y, x, start, len) (y = ((y) & ~BIT_MASK(start, len)) | BIT_PREP(x, start, len))

#define BIT_IS_EVEN(x)     (((x)&1) == 0)
#define BIT_IS_ODD(x)      (!BIT_IS_EVEN((x)))
#define BIT_IS_POW2(x)     (!((x) & ((x)-1)))
#define BIT_TURNOFF_1(x)   ((x) &= ((x)-1))
#define BIT_ISOLATE_1(x)   ((x) &= (-(x)))
#define BIT_PROPAGATE_1(x) ((x) |= ((x)-1))
#define BIT_ISOLATE_0(x)   ((x) = ~(x) & ((x) + 1))
#define BIT_TURNON_0(x)    ((x) |= ((x) + 1))
#define CLAMP_TO_ONE(x)    (!!(x))  // compiler defined, not stardard.    0 --> 0,   1 --> 0xffffffff

#define ONES(x) BIT_MASK_LEN(x)
#define ONES_32 0xffffffff
#define ALL_SET 0xffffffff

// Return the bit index of the lowest 1 in y.   ex:  0b00110111000  --> 3
#define BIT_LOW_BIT(y)  (((y) & BIT(0))?0:(((y) & BIT(1))?1:(((y) & BIT(2))?2:(((y) & BIT(3))?3:            \
                        (((y) & BIT(4))?4:(((y) & BIT(5))?5:(((y) & BIT(6))?6:(((y) & BIT(7))?7:                \
                        (((y) & BIT(8))?8:(((y) & BIT(9))?9:(((y) & BIT(10))?10:(((y) & BIT(11))?11:            \
                        (((y) & BIT(12))?12:(((y) & BIT(13))?13:(((y) & BIT(14))?14:(((y) & BIT(15))?15:        \
                        (((y) & BIT(16))?16:(((y) & BIT(17))?17:(((y) & BIT(18))?18:(((y) & BIT(19))?19:        \
                        (((y) & BIT(20))?20:(((y) & BIT(21))?21:(((y) & BIT(22))?22:(((y) & BIT(23))?23:        \
                        (((y) & BIT(24))?24:(((y) & BIT(25))?25:(((y) & BIT(26))?26:(((y) & BIT(27))?27:        \
                        (((y) & BIT(28))?28:(((y) & BIT(29))?29:(((y) & BIT(30))?30:(((y) & BIT(31))?31:32      \
                        ))))))))))))))))))))))))))))))))

// Return the bit index of the highest 1 in (y).   ex:  0b00110111000  --> 8
#define BIT_HIGH_BIT(y)  (((y) & BIT(31))?31:(((y) & BIT(30))?30:(((y) & BIT(29))?29:(((y) & BIT(28))?28:   \
                        (((y) & BIT(27))?27:(((y) & BIT(26))?26:(((y) & BIT(25))?25:(((y) & BIT(24))?24:        \
                        (((y) & BIT(23))?23:(((y) & BIT(22))?22:(((y) & BIT(21))?21:(((y) & BIT(20))?20:        \
                        (((y) & BIT(19))?19:(((y) & BIT(18))?18:(((y) & BIT(17))?17:(((y) & BIT(16))?16:        \
                        (((y) & BIT(15))?15:(((y) & BIT(14))?14:(((y) & BIT(13))?13:(((y) & BIT(12))?12:        \
                        (((y) & BIT(11))?11:(((y) & BIT(10))?10:(((y) & BIT(9))?9:(((y) & BIT(8))?8:            \
                        (((y) & BIT(7))?7:(((y) & BIT(6))?6:(((y) & BIT(5))?5:(((y) & BIT(4))?4:                \
                        (((y) & BIT(3))?3:(((y) & BIT(2))?2:(((y) & BIT(1))?1:(((y) & BIT(0))?0:32              \
                        ))))))))))))))))))))))))))))))))

#define BM_MASK_FLD(x, mask)        (((x) & (mask)) >> BIT_LOW_BIT(mask))
#define BM_SET_MASK_FLD(x, mask, v) ((x) = BM_MASK_VAL(x, mask, v))

//////////////////////
#define MV(m, v) (((v) << BIT_LOW_BIT(m)) & (m))

// warning MASK_VALn  are internal used macro, please use MASK_VAL instead
#define MASK_VAL2(m, v)                           (MV(m, v))
#define MASK_VAL4(m1, v1, m2, v2)                 (MV(m1, v1) | MV(m2, v2))
#define MASK_VAL6(m1, v1, m2, v2, m3, v3)         (MV(m1, v1) | MV(m2, v2) | MV(m3, v3))
#define MASK_VAL8(m1, v1, m2, v2, m3, v3, m4, v4) (MV(m1, v1) | MV(m2, v2) | MV(m3, v3) | MV(m4, v4))
#define MASK_VAL10(m1, v1, m2, v2, m3, v3, m4, v4, m5, v5)                                                            \
    (MV(m1, v1) | MV(m2, v2) | MV(m3, v3) | MV(m4, v4) | MV(m5, v5))
#define MASK_VAL12(m1, v1, m2, v2, m3, v3, m4, v4, m5, v5, m6, v6)                                                    \
    (MV(m1, v1) | MV(m2, v2) | MV(m3, v3) | MV(m4, v4) | MV(m5, v5) | MV(m6, v6))
#define MASK_VAL14(m1, v1, m2, v2, m3, v3, m4, v4, m5, v5, m6, v6, m7, v7)                                            \
    (MV(m1, v1) | MV(m2, v2) | MV(m3, v3) | MV(m4, v4) | MV(m5, v5) | MV(m6, v6) | MV(m7, v7))
#define MASK_VAL16(m1, v1, m2, v2, m3, v3, m4, v4, m5, v5, m6, v6, m7, v7, m8, v8)                                    \
    (MV(m1, v1) | MV(m2, v2) | MV(m3, v3) | MV(m4, v4) | MV(m5, v5) | MV(m6, v6) | MV(m7, v7) | MV(m8, v8))

#define MASK_VAL(...) VARARG(MASK_VAL, __VA_ARGS__)

#define FLD_MASK_VAL(x, mask, v) BM_MASK_VAL(x, mask, MV(mask, v))

#define SET_FLD(x, mask)  BM_SET(x, mask)
#define CLR_FLD(x, mask)  BM_CLR(x, mask)
#define FLIP_FLD(x, mask) BM_FLIP(x, mask)

#define GET_FLD(x, mask) BM_MASK_FLD(x, mask)

#define SET_FLD_V(...) VARARG(SET_FLD_V, __VA_ARGS__)

#define SET_FLD_FULL_V3(x, m, v)                           ((x) = MASK_VAL2(m, v))
#define SET_FLD_FULL_V5(x, m1, v1, m2, v2)                 ((x) = MASK_VAL4(m1, v1, m2, v2))
#define SET_FLD_FULL_V7(x, m1, v1, m2, v2, m3, v3)         ((x) = MASK_VAL6(m1, v1, m2, v2, m3, v3))
#define SET_FLD_FULL_V9(x, m1, v1, m2, v2, m3, v3, m4, v4) ((x) = MASK_VAL8(m1, v1, m2, v2, m3, v3, m4, v4))
#define SET_FLD_FULL_V11(x, m1, v1, m2, v2, m3, v3, m4, v4, m5, v5)                                                   \
    ((x) = MASK_VAL10(m1, v1, m2, v2, m3, v3, m4, v4, m5, v5))
#define SET_FLD_FULL_V13(x, m1, v1, m2, v2, m3, v3, m4, v4, m5, v5, m6, v6)                                           \
    ((x) = MASK_VAL12(m1, v1, m2, v2, m3, v3, m4, v4, m5, v5, m6, v6))
#define SET_FLD_FULL_V(...) VARARG(SET_FLD_FULL_V, __VA_ARGS__)

////////////////////////////////////////////////////////////////////////
#define BIT8_IFY(y)                                                                                                   \
    ((((y) & 0x0000000FLU) ? 1 : 0) + (((y) & 0x000000F0LU) ? 2 : 0) + (((y) & 0x00000F00LU) ? 4 : 0) +               \
     (((y) & 0x0000F000LU) ? 8 : 0) + (((y) & 0x000F0000LU) ? 16 : 0) + (((y) & 0x00F00000LU) ? 32 : 0) +             \
     (((y) & 0x0F000000LU) ? 64 : 0) + (((y) & 0xF0000000LU) ? 128 : 0))

#define HEX_X(i) (0x##i##LU)

#define BIT_8(j) ((unsigned char)BIT8_IFY(HEX_X(j)))

#ifndef WIN32
// warning SET_FLD_Vn  are internal used macro, please use SET_FLD_V instead
#define SET_FLD_V3(x, m, v) BM_SET_MASK_FLD(x, m, MV(m, v))

#define SET_FLD_V5(x, m1, v1, m2, v2) BM_SET_MASK_FLD(x, (m1) | (m2), MV(m1, v1) | MV(m2, v2))

#define SET_FLD_V7(x, m1, v1, m2, v2, m3, v3)                                                                         \
    BM_SET_MASK_FLD(x, (m1) | (m2) | (m3), MV(m1, v1) | MV(m2, v2) | MV(m3, v3))

#define SET_FLD_V9(x, m1, v1, m2, v2, m3, v3, m4, v4)                                                                 \
    BM_SET_MASK_FLD(x, (m1) | (m2) | (m3) | (m4), MV(m1, v1) | MV(m2, v2) | MV(m3, v3) | MV(m4, v4))

#define SET_FLD_V11(x, m1, v1, m2, v2, m3, v3, m4, v4, m5, v5)                                                        \
    BM_SET_MASK_FLD(x, (m1) | (m2) | (m3) | (m4) | (m5),                                                              \
                    MV(m1, v1) | MV(m2, v2) | MV(m3, v3) | MV(m4, v4) | MV(m5, v5))

#define SET_FLD_V13(x, m1, v1, m2, v2, m3, v3, m4, v4, m5, v5, m6, v6)                                                \
    BM_SET_MASK_FLD(x, (m1) | (m2) | (m3) | (m4) | (m5) | (m6),                                                       \
                    MV(m1, v1) | MV(m2, v2) | MV(m3, v3) | MV(m4, v4) | MV(m5, v5) | MV(m6, v6))
#else
#define SET_FLD_V3(x, m, v)                                                                                           \
    __pragma(warning(push)) __pragma(warning(disable : 4244)) BM_SET_MASK_FLD(x, m, MV(m, v)) __pragma(warning(pop))

#define SET_FLD_V5(x, m1, v1, m2, v2)                                                                                 \
    __pragma(warning(push)) __pragma(warning(disable : 4244))                                                         \
        BM_SET_MASK_FLD(x, (m1) | (m2), MV(m1, v1) | MV(m2, v2)) __pragma(warning(pop))

#define SET_FLD_V7(x, m1, v1, m2, v2, m3, v3)                                                                         \
    __pragma(warning(push)) __pragma(warning(disable : 4244))                                                         \
        BM_SET_MASK_FLD(x, (m1) | (m2) | (m3), MV(m1, v1) | MV(m2, v2) | MV(m3, v3)) __pragma(warning(pop))

#define SET_FLD_V9(x, m1, v1, m2, v2, m3, v3, m4, v4)                                                                 \
    __pragma(warning(push)) __pragma(warning(disable : 4244))                                                         \
        BM_SET_MASK_FLD(x, (m1) | (m2) | (m3) | (m4), MV(m1, v1) | MV(m2, v2) | MV(m3, v3) | MV(m4, v4))                      \
            __pragma(warning(pop))

#define SET_FLD_V11(x, m1, v1, m2, v2, m3, v3, m4, v4, m5, v5)                                                        \
    __pragma(warning(push)) __pragma(warning(disable : 4244))                                                         \
        BM_SET_MASK_FLD(x, (m1) | (m2) | (m3) | (m4) | (m5),                                                          \
                        MV(m1, v1) | MV(m2, v2) | MV(m3, v3) | MV(m4, v4) | MV(m5, v5)) __pragma(warning(pop))

#define SET_FLD_V13(x, m1, v1, m2, v2, m3, v3, m4, v4, m5, v5, m6, v6)                                                \
    __pragma(warning(push)) __pragma(warning(disable : 4244))                                                         \
        BM_SET_MASK_FLD(x, (m1) | (m2) | (m3) | (m4) | (m5) | (m6),                                                   \
                        MV(m1, v1) | MV(m2, v2) | MV(m3, v3) | MV(m4, v4) | MV(m5, v5) | MV(m6, v6))                  \
            __pragma(warning(pop))
#endif